home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / modelers / geomview / source.lha / Geomview / src / lib / gprim / geom / geomstream.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-10  |  7.3 KB  |  345 lines
  1. /* Copyright (c) 1992 The Geometry Center; University of Minnesota
  2.    1300 South Second Street;  Minneapolis, MN  55454, USA;
  3.    
  4. This file is part of geomview/OOGL. geomview/OOGL is free software;
  5. you can redistribute it and/or modify it only under the terms given in
  6. the file COPYING, which you should have received along with this file.
  7. This and other related software may be obtained via anonymous ftp from
  8. geom.umn.edu; email: software@geom.umn.edu. */
  9.  
  10. /* Authors: Charlie Gunn, Stuart Levy, Tamara Munzner, Mark Phillips */
  11.  
  12. #include <stdio.h>
  13. #include <string.h>
  14. #include "geomclass.h"
  15. #include "streampool.h"
  16. #include "handleP.h"
  17.  
  18.  
  19. HandleOps GeomOps = {
  20.     "geom",
  21.     GeomStreamIn,
  22.     GeomStreamOut,
  23.     GeomDelete,
  24.     NULL,        /* resync */
  25.     NULL,        /* close pool */
  26. };
  27.  
  28. Geom *
  29. GeomLoad(char *fname)
  30. {
  31.     FILE *inf = fopen(fname, "r");
  32.     Geom *g;
  33.  
  34.     if(inf == NULL) {
  35.     OOGLError(0, "GeomLoad: can't open %s: %s", fname, sperror());
  36.     return NULL;
  37.     }
  38.     g = GeomFLoad(inf, fname);
  39.     fclose(inf);
  40.     return g;
  41. }
  42.  
  43. Geom *
  44. GeomFLoad(FILE *inf, char *fname)
  45. {
  46.     Pool *p;
  47.     Geom *g = NULL;
  48.  
  49.     p = PoolStreamTemp(fname, inf, 0, NULL);
  50.     GeomStreamIn(p, NULL, &g);
  51.     PoolDelete(p);
  52.     return g;
  53. }
  54.  
  55. int
  56. GeomFLoadEmbedded( Geom **gp, Handle **hp, FILE *inf, char *fname )
  57. {
  58.     Pool *p;
  59.     int nope;
  60.  
  61.     p = PoolStreamTemp(fname, inf, 0, NULL);
  62.     nope = GeomStreamIn(p, hp, gp);
  63.     PoolDelete(p);
  64.     return !nope;
  65. }
  66.  
  67. Geom *
  68. GeomSave(Geom *g, char *fname)
  69. {
  70.     Pool *p;
  71.     int ok;
  72.  
  73.     p = PoolStreamTemp(fname, NULL, 1, &GeomOps);
  74.     if(p == NULL) {
  75.     OOGLError(0, "GeomSave: Can't open %s: %s", fname, sperror());
  76.     return NULL;
  77.     }
  78.     PoolSetOType(p, PO_DATA);
  79.     ok = GeomStreamOut(p, NULL, g);
  80.     PoolClose(p);
  81.     PoolDelete(p);
  82.     return ok ? g : NULL;
  83. }
  84.  
  85. Geom *
  86. GeomFSave(Geom *g, FILE *outf, char *fname)
  87. {
  88.     Pool *p;
  89.     int ok;
  90.  
  91.     p = PoolStreamTemp(fname, outf, 1, NULL);
  92.     PoolSetOType(p, PO_DATA);
  93.     PoolIncLevel(p,1);
  94.     ok = GeomStreamOut(p, NULL, g);
  95.     PoolDelete(p);
  96.     return ok ? g : NULL;
  97. }
  98.  
  99. Geom *
  100. GeomFSaveEmbedded( Geom *g, Handle *handle, FILE *outf, char *fname )
  101. {
  102.     Pool *p;
  103.     int ok;
  104.  
  105.     p = PoolStreamTemp(fname, outf, 1, NULL);
  106.     PoolSetOType(p, PO_HANDLES);
  107.     PoolIncLevel(p, 1);        /* Enforce level > 0 to get { braces } */
  108.     ok = GeomStreamOut(p, handle, g);
  109.     PoolDelete(p);
  110.     return ok ? g : NULL;
  111. }
  112.  
  113. int
  114. GeomEmbedPrefix(int c)
  115. { return (c == '{' || c == '=' || c == '@' || c == '<'); }
  116.  
  117. int
  118. GeomStreamIn(Pool *p, Handle **hp, Geom **gp)
  119. {
  120.     FILE *f;
  121.     Handle *h = NULL;
  122.     Handle *hname = NULL;
  123.     Geom *g = NULL;
  124.     Handle *aphandle = NULL;
  125.     Appearance *ap = NULL;
  126.     GeomClass *Class;
  127.     void *it;
  128.     struct stdio_mark *mark = NULL;
  129.     int first;
  130.     int empty = 1, braces = 0;
  131.     Geom **tgp;
  132.     Handle **thp;
  133.     int c;
  134.     char *w, *raww, *tail;
  135.     int brack = 0;
  136.     int more;
  137.     char longname[512];
  138.  
  139.     if(p == NULL || (f = PoolInputFile(p)) == NULL)
  140.     return 0;
  141.  
  142.     /* Skip a semicolon if it's the first thing we see -- 'stuff' compatibility.
  143.      */
  144.     if(fnextc(f, 0) == ';')
  145.     fgetc(f);
  146.  
  147.     do {
  148.     more = 0;
  149.     switch(c = fnextc(f, 0)) {
  150.     case '<':
  151.     case ':':
  152.     case '@':
  153.         fgetc(f);
  154.         w = fdelimtok("{}()", f, 0);
  155.         /*
  156.          * Consider doing a path search.
  157.          * Do this before calling HandleReferringTo()
  158.          * to prevent spurious error messages.
  159.          */
  160.         if(c == '<' && (h = HandleByName(w, &GeomOps)) == NULL && w[0] != '/') {
  161.         w = findfile(PoolName(p), raww = w);
  162.         if(w == NULL) {
  163.             OOGLSyntax(PoolInputFile(p),
  164.             "Error reading \"%s\": can't find file \"%s\"",
  165.             PoolName(p), raww);
  166.         }
  167.         }
  168.         h = HandleReferringTo(c, w, &GeomOps, NULL);
  169.         if(h != NULL) {
  170.         g = (Geom *)HandleObject(h);
  171.         RefIncr((Ref*)g);
  172.         }
  173.         break;
  174.  
  175.     case '{':
  176.         brack++;
  177.         fgetc(f);
  178.         break;
  179.     case '}':
  180.         if(brack--) { fgetc(f); braces = 1; }
  181.         break;
  182.  
  183.     case 'g':
  184.         if(fexpectstr(f, "geom"))
  185.         return 0;
  186.         more = 1;
  187.         break;
  188.  
  189.     case 'd':
  190.         if(fexpectstr(f, "define"))
  191.         return 0;
  192.         more = 1;
  193.         hname = HandleCreate( ftoken(PoolInputFile(p), 0), &GeomOps );
  194.         break;
  195.  
  196.     case 'a':
  197.         if(fexpectstr(f, "appearance"))
  198.         return 0;
  199.         ap = ApFLoad(NULL, PoolInputFile(p), PoolName(p));
  200.         more = 1;
  201.         break;
  202.  
  203.     case '=':
  204.         fgetc(f);            /* Skip '=' and fall into... */
  205.  
  206.     default:
  207.         /*
  208.          * Load literal object.
  209.          * First try to guess object type from its file name.
  210.          */
  211.         empty = 0;
  212.         (void) fnextc(f, 0);    /* [Prime stdio buffer] */
  213.         mark = stdio_setmark( NULL, PoolInputFile(p) );
  214.  
  215.         Class = GeomFName2Class( PoolName(p) );
  216.  
  217.         g = NULL;
  218.         first = 1;
  219.         tgp = gp ? gp : &g;
  220.         thp = hp ? hp : &h;
  221.  
  222.         if(Class) {
  223.         if(Class->import)
  224.             g = (*Class->import)(p);
  225.         else if(Class->fload)
  226.             g = (*Class->fload)(PoolInputFile(p), PoolName(p));
  227.         first = 0;
  228.         if(g)
  229.             break;
  230.         }
  231.  
  232.         /*
  233.          * If not, try all known classes.
  234.          */
  235.         GeomKnownClassInit();    /* Ensure all classes entered */
  236.  
  237.         it = GeomClassIterate();
  238.         while (g == NULL && (Class = GeomNextClass(&it)) != NULL) {
  239.         if(Class->import == NULL && Class->fload == NULL)
  240.             continue;
  241.         /*
  242.          * Try to seek back to our initial position.
  243.          */
  244.         if(!first && !stdio_seekmark(mark)) {
  245.             /* No luck.  Might as well give up right now. */
  246.             OOGLSyntax(PoolInputFile(p),
  247.             "Error reading \"%s\": can't seek back far enough (on pipe?)",
  248.                 PoolName(p));
  249.             break;
  250.         }
  251.  
  252.         if(Class->import)
  253.             g = (*Class->import)(p);
  254.         else if(Class->fload)
  255.             g = (*Class->fload)(PoolInputFile(p), PoolName(p));
  256.         first = 0;
  257.         }
  258.         if(g == NULL) {
  259.         OOGLFree(mark);
  260.         return 0;
  261.         }
  262.     }
  263.     } while(brack > 0 || more);
  264.  
  265.  
  266.     if(hname != NULL) {
  267.     if(g)
  268.         HandleSetObject(hname, (Ref *)g);
  269.     h = hname;
  270.     }
  271.  
  272.     /*
  273.      * Leave results where we're told to
  274.      */
  275.     if(h != NULL && hp != NULL && *hp != h) {
  276.     if(*hp)
  277.         HandlePDelete(hp);
  278.     *hp = h;
  279.     }
  280.     if(ap != NULL || aphandle != NULL) {
  281.     if(g == NULL)
  282.        g = GeomCreate("inst", CR_END);
  283.     if(g->ap)
  284.         ApDelete(g->ap);
  285.     if(g->aphandle)
  286.         HandlePDelete(&g->aphandle);
  287.     g->ap = ap;
  288.     g->aphandle = aphandle;
  289.     }
  290.     if(g != NULL && gp != NULL && *gp != g) {
  291.     if(*gp != NULL)
  292.         GeomDelete(*gp);
  293.     *gp = g;
  294.     } else if(g)        /* Maintain ref count */
  295.     GeomDelete(g);
  296.  
  297.     if(mark != NULL)
  298.     OOGLFree(mark);
  299.     return (g != NULL || h != NULL || (empty && braces));
  300. }
  301.  
  302.  
  303. int
  304. GeomStreamOut(Pool *p, Handle *h, Geom *g)
  305. {
  306.     int putdata;
  307.     int brack;
  308.  
  309.     if(PoolOutputFile(p) == NULL)
  310.       return 0;
  311.  
  312.     if(g == NULL && h != NULL && h->object != NULL)
  313.     g = (Geom *)h->object;
  314.  
  315.     if(g == NULL && h == NULL) {
  316.     fprintf(PoolOutputFile(p), "{ }\n");
  317.     return 1;
  318.     }
  319.  
  320.     brack = (p->level > 0 || (g && (g->ap || g->aphandle)) || h != NULL);
  321.  
  322.     if(brack)
  323.     fprintf(PoolOutputFile(p), "{ ");
  324.  
  325.     if(p->otype & 4) fprintf(PoolOutputFile(p), "# %d refs\n", g->ref_count); /* debug */
  326.  
  327.     if(g && (g->ap || g->aphandle))
  328.     ApFSave(g->ap, g->aphandle, PoolOutputFile(p), PoolName(p));
  329.  
  330.     putdata = PoolStreamOutHandle( p, h, g != NULL );
  331.     if(g != NULL && putdata) {
  332.     if(brack)
  333.         fprintf(PoolOutputFile(p), "= ");
  334.     PoolIncLevel(p, 1);
  335.     if(g->Class->export)
  336.         (*g->Class->export)(g, p);
  337.     else if(g->Class->fsave)
  338.         (*g->Class->fsave)(g, PoolOutputFile(p), PoolName(p));
  339.     PoolIncLevel(p, -1);
  340.     }
  341.     if(brack)
  342.     fprintf(PoolOutputFile(p), "}\n");
  343.     return !ferror(PoolOutputFile(p));
  344. }
  345.